JavaScripti Proxy Handleri valideerimine: tüübikindel objektide pealtkuulamine

JavaScripti Proxyd pakuvad võimsat mehhanismi põhiliste objektide operatsioonide pealtkuulamiseks ja kohandamiseks. Üks veenvamaid kasutusjuhtumeid on andmete valideerimine. Proxy handlerite abil saate jõustada piiranguid ja tüübikindlust objektide omaduste kohta, mis viib tugevama ja hooldatavama koodini. See ajaveebipostitus uurib, kuidas kasutada JavaScripti Proxisid tõhusaks objektide valideerimiseks, pakkudes praktilisi näiteid ja juhiseid igasuguse tasemega arendajatele. Me käsitleme erinevaid handleri meetodeid ja demonstreerime, kuidas neid saab kasutada andmete terviklikkuse tagamiseks.

JavaScripti Proxyde mõistmine

Enne valideerimisse süvenemist vaatame lühidalt üle, mis on JavaScripti Proxyd ja kuidas need töötavad. Proxy objekt mähkub teise objekti (sihtmärk) ja kuulab pealt selle sihtmärgi kohta tehtud toiminguid. Proxy võimaldab teil määratleda kohandatud käitumist selliste toimingute jaoks nagu omaduse hankimine, omaduse määramine, funktsiooni kutsumine või uue objekti loomine. See kohandamine saavutatakse handleri abil, mis on objekt, mis sisaldab meetodeid, mis kuulavad pealt konkreetseid operatsioone.

Proxy loomise põhiline süntaks on:

            const proxy = new Proxy(target, handler);
            

              
                Copy
              
            
          

• target: Objekt, mis mähitakse Proxiga.
• handler: Objekt, mis sisaldab meetodeid (lõkse), mis kuulavad pealt toiminguid sihtmärgi kohta.

Proxy Handleri meetodid valideerimiseks

Handleri objekt võib sisaldada erinevaid meetodeid, millest igaüks vastab erinevale toimingule sihtobjekti kohta. Siin on mõned kõige olulisemad meetodid valideerimiseks:

• get(target, property, receiver): Kuulab pealt omaduste juurdepääsu.
• set(target, property, value, receiver): Kuulab pealt omaduse määramist.
• apply(target, thisArg, argumentsList): Kuulab pealt funktsioonikõnesid.
• construct(target, argumentsList, newTarget): Kuulab pealt operaatorit new.
• deleteProperty(target, property): Kuulab pealt operaatorit delete.
• defineProperty(target, property, descriptor): Kuulab pealt omaduse määratlust.
• has(target, property): Kuulab pealt operaatorit in.
• ownKeys(target): Kuulab pealt Object.getOwnPropertyNames(), Object.getOwnPropertySymbols() ja Reflect.ownKeys().
• preventExtensions(target): Kuulab pealt Object.preventExtensions().
• getPrototypeOf(target): Kuulab pealt Object.getPrototypeOf().
• setPrototypeOf(target, prototype): Kuulab pealt Object.setPrototypeOf().

Keskendume peamiselt handleritele get, set, apply ja construct, kuna neid kasutatakse kõige sagedamini valideerimise eesmärgil.

Omaduste määramise valideerimine handleriga set

Handler set on oluline omaduste määramise valideerimiseks. See võimaldab teil pealt kuulata katseid muuta objekti omadusi ja jõustada piiranguid enne, kui määramine tegelikult toimub.

Näide: Tüübikontroll

Loome Proxy, mis jõustab tüübikontrolli objekti Person omaduste jaoks. Me tagame, et name on alati string ja age on alati number.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'name' && typeof value !== 'string') {
      throw new TypeError('Nimi peab olema string');
    }
    if (property === 'age' && typeof value !== 'number') {
      throw new TypeError('Vanus peab olema number');
    }
    // Järgmine rida on oluline omaduse tegelikuks määramiseks.
    target[property] = value;
    return true; // Näitab õnnestumist
  }
};

const proxy = new Proxy(person, validator);

proxy.name = 'Jane Smith'; // Töötab hästi
proxy.age = 25; // Töötab hästi

try {
  proxy.age = '40'; // Visab TypeError
} catch (e) {
  console.error(e);
}

console.log(proxy.age); // Väljund: 25

            

              
                Copy
              
            
          

Selles näites kontrollib handler set väärtuse tüüpi, mis on määratud name'ile ja age'ile. Kui tüüp on vale, viskab see TypeError'i, takistades määramist. On oluline lisada handlerisse `target[property] = value;` , et tegelikult väärtust määrata; vastasel juhul ei uuendata omadust.

Näide: Vahemiku valideerimine

Samuti saame valideerida, et omadus jääb konkreetse vahemiku sisse. Näiteks tagame, et age on alati vahemikus 0 kuni 120.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'age') {
      if (typeof value !== 'number') {
        throw new TypeError('Vanus peab olema number');
      }
      if (value < 0 || value > 120) {
        throw new RangeError('Vanus peab olema vahemikus 0 kuni 120');
      }
    }
    target[property] = value;
    return true;
  }
};

const proxy = new Proxy(person, validator);

proxy.age = 50; // Töötab hästi

try {
  proxy.age = -5; // Visab RangeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Omaduse juurdepääsu valideerimine handleriga get

Kuigi see on range valideerimiseks vähem levinud, saab handlerit get kasutada transformatsioonide või valideerimiste tegemiseks, kui omadusele ligipääs on. Näiteks võiksite vormindada telefoninumbri või tagada kuupäeva kehtivuse enne selle tagastamist.

Näide: Kirjutuskaitstud omadused

Saate simuleerida kirjutuskaitstud omadusi, visates vea, kui keegi üritab pääseda ligi omadusele, mida ei tohiks otse lugeda.

            const config = {
  apiKey: 'salajane_võti'
};

const validator = {
  get: function(target, property) {
    if (property === 'apiKey') {
      throw new Error('Ei saa otse apiKey'le ligi pääseda. Kasutage turvalist meetodit.');
    }
    return target[property];
  }
};

const proxy = new Proxy(config, validator);

try {
  console.log(proxy.apiKey); // Visab Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

See lähenemine takistab otsest juurdepääsu tundlikele andmetele, sundides arendajaid kasutama kontrollitud meetodit võtme hankimiseks (nt funktsioon, mis haldab autentimist).

Funktsiooni kõnede valideerimine handleriga apply

Handler apply võimaldab teil pealt kuulata funktsioonikõnesid ja valideerida funktsioonile edastatud argumente. See on eriti kasulik tagamaks, et funktsioonid saavad õigeid tüüpe ja argumentide arvu.

Näide: Argumendi tüübi valideerimine

Loome Proxy, mis valideerib argumendid, mis on edastatud funktsioonile, mis arvutab ristküliku pindala.

            function calculateArea(width, height) {
  return width * height;
}

const validator = {
  apply: function(target, thisArg, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('calculateArea nõuab täpselt kahte argumenti: laius ja kõrgus.');
    }

    const width = argumentsList[0];
    const height = argumentsList[1];

    if (typeof width !== 'number' || typeof height !== 'number') {
      throw new TypeError('Laius ja kõrgus peavad olema numbrid.');
    }

    if (width <= 0 || height <= 0) {
      throw new RangeError('Laius ja kõrgus peavad olema positiivsed väärtused.');
    }

    return target.apply(thisArg, argumentsList);
  }
};

const proxy = new Proxy(calculateArea, validator);

console.log(proxy(5, 10)); // Väljund: 50

try {
  console.log(proxy(5)); // Visab Error
} catch (e) {
  console.error(e);
}

try {
  console.log(proxy('5', 10)); // Visab TypeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Selles näites kontrollib handler apply argumentide arvu ja tüüpe, mis on edastatud funktsioonile calculateArea. Kui argumendid on valed, viskab see vea enne, kui funktsioon tegelikult täidetakse. Oluline rida `return target.apply(thisArg, argumentsList);` tegelikult käivitab originaalfunktsiooni koos pakutud argumentidega.

Objekti loomise valideerimine handleriga construct

Handler construct võimaldab teil pealt kuulata operaatorit new ja valideerida konstruktori funktsioonile edastatud argumente. See on eriti kasulik konstruktorite abil loodud objektide piirangute jõustamiseks.

Näide: Nõutavad omadused

Loome Proxy, mis tagab, et objekt User on alati loodud koos username'i ja email'iga.

            class User {
  constructor(username, email) {
    this.username = username;
    this.email = email;
  }
}

const validator = {
  construct: function(target, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('Kasutaja konstruktor nõuab kahte argumenti: kasutajanimi ja e-post.');
    }

    const username = argumentsList[0];
    const email = argumentsList[1];

    if (typeof username !== 'string' || username.length === 0) {
      throw new TypeError('Kasutajanimi peab olema mittetühi string.');
    }

    if (typeof email !== 'string' || !email.includes('@')) {
      throw new TypeError('E-post peab olema kehtiv e-posti aadress.');
    }

    return new target(...argumentsList);
  }
};

const UserProxy = new Proxy(User, validator);

const user1 = new UserProxy('john.doe', 'john.doe@example.com'); // Töötab hästi

try {
  const user2 = new UserProxy('john.doe'); // Visab Error
} catch (e) {
  console.error(e);
}

try {
  const user3 = new UserProxy('john.doe', 'invalid_email'); // Visab TypeError
} catch (e) {
  console.error(e);
}

console.log(user1);

            

              
                Copy
              
            
          

Selles näites kontrollib handler construct argumentide arvu ja tüüpe, mis on edastatud konstruktorile User. Kui argumendid on valed, viskab see vea enne, kui objekt luuakse. Rida `return new target(...argumentsList);` tegelikult loob uue klassi eksemplari, kasutades antud argumente.

Täiustatud valideerimistehnikad

Lisaks põhilisele tüübikontrollile ja vahemiku valideerimisele saab Proxisid kasutada ka täiustatud valideerimisstsenaariumide jaoks.

Ristiomaduste valideerimine

Saate kasutada Proxysid erinevate omaduste vaheliste suhete valideerimiseks. Näiteks võiksite tagada, et alguskuupäev on alati enne lõppkuupäeva.

            const event = {
  startDate: '2024-01-15',
  endDate: '2024-01-20'
};

const validator = {
  set: function(target, property, value) {
    target[property] = value; // Määra väärtus esimesena

    if (property === 'endDate' && target.startDate > target.endDate) {
      throw new Error('Lõppkuupäev peab olema pärast alguskuupäeva.');
    }

    return true;
  }
};

const proxy = new Proxy(event, validator);

proxy.endDate = '2024-01-25'; // Töötab hästi

try {
  proxy.endDate = '2024-01-10'; // Visab Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Asünkroonne valideerimine

Kuigi vähem levinud, saate Proxysid kasutada asünkroonsete operatsioonidega keerukamate valideerimistsenaariumide jaoks. See võib hõlmata API-kõnede tegemist andmete valideerimiseks väliste allikatega.

Oluline märkus: Asünkroonsed operatsioonid Proxy handlerites võivad olla keerukad ja neid tuleks hoolikalt käsitseda, et vältida sündmuseloobi blokeerimist. Sageli on parem teostada asünkroonne valideerimine väljaspool Proxy handlerit ja seejärel kasutada Proxy't tulemuste jõustamiseks.

Proxyde kasutamise eelised valideerimiseks

• Tsentraliseeritud valideerimisloogika: Proxyd võimaldavad teil valideerimisloogika tsentraliseerida ühes kohas, muutes selle hooldamise ja värskendamise lihtsamaks.
• Parem koodi loetavus: Valideerimisloogika eraldamisega põhiobjekti loogikast saate parandada koodi loetavust ja hooldatavust.
• Täiustatud tüübikindlus: Proxyd aitavad jõustada tüübikindlust, vähendades vigade ohtu, mis on põhjustatud valedest andmetüüpidest.
• Paindlikkus ja kohandamine: Proxyd pakuvad suurt paindlikkust, võimaldades teil kohandada valideerimisreegleid vastavalt teie rakenduse konkreetsetele vajadustele.

Proxyde kasutamise piirangud

• Jõudluse lisakulu: Proxyd toovad kaasa väikese jõudluse lisakulu objektide operatsioonide pealtkuulamise tõttu. See lisakulu on enamiku rakenduste jaoks tavaliselt tühine, kuid seda on oluline arvestada kriitilise jõudlusega stsenaariumides.
• Ühilduvus: Kuigi Proxysid toetavad kaasaegsed brauserid ja Node.js, ei toetata neid vanemates keskkondades. Võimalik, et peate kasutama polyfille vanemate brauseritega ühilduvuse tagamiseks.
• Silumine: Proxysid kasutava koodi silumine võib olla veidi keerulisem objektide operatsioonide pealtkuulamise tõttu. Kuid kaasaegsed arendustööriistad pakuvad Proxyside silumiseks head tuge.

Proxy Handleri valideerimise parimad tavad

• Hoidke handlerid lihtsana: Vältige Proxy handlerites keerulist loogikat, et minimeerida jõudluse lisakulu ja parandada loetavust.
• Esitage selged veateated: Visake informatiivsed veateated, mis aitavad arendajatel mõista, miks valideerimine ebaõnnestus.
• Arvestage jõudlusega: Olge teadlik Proxyde jõudlusmõjust, eriti kriitilise jõudlusega rakendustes.
• Kasutage ettevaatusega: Ärge kasutage Proxysid liiga palju. Kasutage neid strateegiliselt valideerimiseks ja muudeks metaprogrammeerimisülesanneteks, kus neist on selge kasu.
• Testige põhjalikult: Testige oma Proxy-põhist valideerimisloogikat põhjalikult, et veenduda selle toimimises ootuspäraselt kõigis stsenaariumides.

Ülemaailmsed kaalutlused valideerimisel

Globaalsele publikule rakenduste arendamisel on valideerimisreeglite rakendamisel oluline arvestada kultuuriliste erinevustega ja piirkondlike variatsioonidega. Siin on mõned peamised kaalutlused:

• Kuupäeva- ja kellaaja vormingud: Kasutage teeki nagu Moment.js või date-fns, et käsitleda kuupäeva- ja kellaaja vorminguid õigesti erinevate lokaatide jaoks. Näiteks Ameerika Ühendriikides vormindatakse kuupäevad sageli kujul MM/DD/YYYY, Euroopas aga tavaliselt DD/MM/YYYY.
• Numbrite vormingud: Olge teadlik erinevatest numbrite vormingutest, sealhulgas kümnendkohakriipsudest ja tuhandete eraldajatest. Mõnes riigis kasutatakse koma kümnendkohana, teistes aga punkti.
• Valuuta vormingud: Kuva valuutaväärtused kasutaja lokaadi jaoks õiges vormingus, sealhulgas sobiv valuutasümbol ja kümnendkohakohasus.
• Aadressi vormingud: Aadressi vormingud erinevad oluliselt kogu maailmas. Kaaluge teegi või API kasutamist, mis toetab rahvusvahelist aadressi valideerimist ja vormindamist.
• Telefoninumbri vormingud: Kasutage teeki, mis toetab rahvusvahelist telefoninumbri valideerimist ja vormindamist, et tagada telefoninumbrite õige sisestamine.
• Nime vormingud: Olge teadlik, et nimede vormingud võivad kultuuriti erineda. Mõned kultuurid kasutavad eesnime, millele järgneb perekonnanimi, teised aga perekonnanime, millele järgneb eesnimi. Samuti on mõnel kultuuril mitu eesnime või perekonnanime.
• Märgistikud: Veenduge, et teie rakendus toetab erinevaid märgistikke ja kodeeringuid, et mahutada nimesid, aadresse ja muid tekstilisi andmeid erinevates keeltes.
• Kultuurilised tundlikkused: Olge valideerimisreegleid kujundades teadlik kultuurilistest tundlikkustest. Näiteks võidakse teatud tüüpi andmeid pidada mõnes kultuuris privaatseks või tundlikuks.

Näide: Rahvusvaheline telefoninumbri valideerimine

            // Eeldades, et kasutate teeki nagu "google-libphonenumber"

import { parsePhoneNumberFromString, AsYouType } from 'google-libphonenumber';

function validatePhoneNumber(phoneNumber, countryCode) {
  try {
    const number = parsePhoneNumberFromString(phoneNumber, countryCode);
    if (number && number.isValid()) {
      return true;
    } else {
      return false;
    }
  } catch (error) {
    return false; // Kehtetu telefoninumbri vorming
  }
}

// Näide (Saksamaa)
const isValidGermanNumber = validatePhoneNumber('+4917612345678', 'DE');
console.log('Kas kehtiv Saksa number:', isValidGermanNumber); // Väljund: true

// Näide (Ameerika Ühendriigid)
const isValidUSNumber = validatePhoneNumber('+15551234567', 'US');
console.log('Kas kehtiv USA number:', isValidUSNumber); // Väljund: true

            

              
                Copy
              
            
          

Järeldus

JavaScripti Proxyd pakuvad võimsat ja paindlikku mehhanismi valideerimisloogika rakendamiseks teie rakendustes. Proxy handlerite abil saate jõustada piiranguid ja tüübikindlust objektide omaduste, funktsiooni argumentide ja objektide loomise kohta, mis viib tugevama, hooldatavama ja turvalisema koodini. Pidage Proxysid kasutades meeles jõudluse tagajärgi ja ühilduvusprobleeme ning testige alati oma valideerimisloogikat põhjalikult. Järgides selles ajaveebipostituses esitatud parimaid tavasid, saate Proxysid tõhusalt kasutada oma JavaScripti rakenduste kvaliteedi ja töökindluse parandamiseks, rahuldades ülemaailmset publikut lokaliseeritud valideerimisstrateegiatega.